package _220314;


//import java.io.*;
//import java.util.Arrays;
//import java.util.LinkedList;
//import java.util.Queue;
//import java.util.Scanner;

import java.io.*;
import java.util.LinkedList;
import java.util.Queue;

/**
 * @author ShadowLim
 * @create 2022-03-14-8:15
 */
public class _发现环 {

//    /** 超时
//     * 链式前向星存图(邻接表)
//     * https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=1711035050&lang=zh_CN#rd
//     */
//    static int N = 100010;
//    static int n, k, idx;               // idx 是用来对边进行编号的
//
//    static int[] h = new int[N];        // 存储的是某个节点所对应的边的集合（链表）的头结点（head）
//    static int[] e = new int[N * 2];    // 由于访问某一条边指向的节点；(node)
//    static int[] ne = new int[2 * N];   // 必须开2倍空间（由于是以链表的形式进行存边，该数组就是用于找到下一条边；）(next)
//    static int[] d = new int[N];        // 入度？？？
//
//    static void add(int a, int b) {
//        e[idx] = b;
//        ne[idx] = h[a];
//        h[a] = idx++;
//    }
//
//    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//        n = scanner.nextInt();
//        // 存图 并统计入度
//        Arrays.fill(h, -1);
//        for (int i = 0; i < n; i++) {
//            int a = scanner.nextInt();
//            int b = scanner.nextInt();
//            add(a, b);
//            add(b, a);
//            d[a]++;
//            d[b]++;
//        }
//
//        String res = "";
//        topsort();
//        // 遍历答案：如果某个节点出现在拓扑序列，说明其进入过队列，说明其入度为 1（该题输出的是出现BUG的节点）
//        for (int i = 1; i < d.length; i++) {
//            if (d[i] > 1) {     // 拓扑排序之后入度仍然大于1 该节点在环上  输出该节点
//                res += i + " ";
//            }
//        }
//        System.out.println(res);
//        scanner.close();
//    }
//
//    // BFS 求图拓扑排序
//    private static void topsort() {
//        LinkedList<Integer> list = new LinkedList<>();  // 链表集合存储节点
//        for (int i = 0; i < d.length; i++) {
//            if (d[i] == 1) { // 入度为1 （该题）
//                list.add(i);
//            }
//        }
//        while (!list.isEmpty()) {
//            int t = list.pop();
//            d[t] = 0;
//            // 如果想要遍历所有由 t 点发出的边时，可以使用如下方式：
//            for (int  i = h[t]; i != -1; i = ne[i]) {
//                int  j = e[i];
//                if (--d[j] == 1) {  // 入度为1 （该题）
//                    list.add(j);
//                }
//            }
//        }
//    }


    /**
     * https://blog.csdn.net/qq_51439643/article/details/123486218?spm=1001.2014.3001.5501
     * @param args
     * @throws IOException
     */

    public static void main(String[] args) throws IOException {
        PrintWriter writer = new PrintWriter(new OutputStreamWriter(System.out));
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(reader);

        // 感觉类似于BufferedReader的readLine()方法
        in.nextToken(); // https://www.jc2182.com/java/java-io-streamtokenizer-nexttoken.html
        int n = (int) in.nval;

        /**
         * tokenizer.nval是一个double值
         * double双精度浮点会有约14到16个十进制数字的精度。
         * 只要你的输入在“数学意义上的有效数字”在14位之内，通常会比较准确。
         * 而long的值会精确到正负10的19次方，也有19个有效数字。
         * 在部分情况会有精度损失。
         * 如果担心精度损失，可以直接对sval字符串进行转换
         * long l=Long.parseLong(tokenizer.sval);
         * 数据在long取值范围内不会有精度损失。
         */


        int[][] arr = new int[n + 1][2];
        int[] inNode = new int[n + 1];

        for (int i = 1; i <= n; ++i) {
            in.nextToken();
            int to = (int) in.nval;
            in.nextToken();
            int from = (int) in.nval;
            // 入度+1
            inNode[to]++;
            inNode[from]++;
            // 保存方向
            if (arr[from][0] != 0) {
                arr[from][1]=to;
            }else{
                arr[from][0] = to;
            }
            if (arr[to][0] != 0) {
                arr[to][1]=from;
            }else{
                arr[to][0] = from;
            }
        }

        // bfs
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 1; i <= n; ++i) {
            // 将入度为1的元素放入队列
            if (inNode[i] == 1) {
                queue.add(i);
                inNode[i]--;
            }
        }
        while (!queue.isEmpty()) {
            int cur = queue.poll();
            // 遍历其相邻结点
            for (int t = 0; t <= 1; ++t) {
                int nx = arr[cur][t];
                if (nx != 0) {
                    arr[cur][t] = 0;
                    inNode[nx]--;
                    if (inNode[nx] == 1) {
                        queue.add(nx);
                    }
                }
            }
        }
        for (int i = 1; i <= n; ++i) {
            if (inNode[i] > 1) {
                writer.print(i + " ");
            }
        }
        writer.flush();
    }
}
